home *** CD-ROM | disk | FTP | other *** search
/ MacWorld 1995 November / Macworld Nov ’95.toast / Developers / Flex 2.5.2 / flex-2.5.2 / yylex.c < prev   
Encoding:
C/C++ Source or Header  |  1995-06-29  |  4.2 KB  |  218 lines  |  [TEXT/MPS ]
  1. /* yylex - scanner front-end for flex */
  2.  
  3. /*-
  4.  * Copyright (c) 1990 The Regents of the University of California.
  5.  * All rights reserved.
  6.  *
  7.  * This code is derived from software contributed to Berkeley by
  8.  * Vern Paxson.
  9.  * 
  10.  * The United States Government has rights in this work pursuant
  11.  * to contract no. DE-AC03-76SF00098 between the United States
  12.  * Department of Energy and the University of California.
  13.  *
  14.  * Redistribution and use in source and binary forms are permitted provided
  15.  * that: (1) source distributions retain this entire copyright notice and
  16.  * comment, and (2) distributions including binaries display the following
  17.  * acknowledgement:  ``This product includes software developed by the
  18.  * University of California, Berkeley and its contributors'' in the
  19.  * documentation or other materials provided with the distribution and in
  20.  * all advertising materials mentioning features or use of this software.
  21.  * Neither the name of the University nor the names of its contributors may
  22.  * be used to endorse or promote products derived from this software without
  23.  * specific prior written permission.
  24.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
  25.  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  26.  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  27.  */
  28.  
  29. /* $Header: /home/daffy/u0/vern/flex/RCS/yylex.c,v 2.13 95/03/04 16:10:41 vern Exp $ */
  30.  
  31. #include <ctype.h>
  32. #include "flexdef.h"
  33. #include "parse.h"
  34.  
  35.  
  36. /* yylex - scan for a regular expression token */
  37.  
  38. int yylex()
  39.     {
  40.     int toktype;
  41.     static int beglin = false;
  42.     extern char *yytext;
  43.  
  44.     if ( eofseen )
  45.         toktype = EOF;
  46.     else
  47.         toktype = flexscan();
  48.  
  49.     if ( toktype == EOF || toktype == 0 )
  50.         {
  51.         eofseen = 1;
  52.  
  53.         if ( sectnum == 1 )
  54.             {
  55.             synerr( _( "premature EOF" ) );
  56.             sectnum = 2;
  57.             toktype = SECTEND;
  58.             }
  59.  
  60.         else
  61.             toktype = 0;
  62.         }
  63.  
  64.     if ( trace )
  65.         {
  66.         if ( beglin )
  67.             {
  68.             fprintf( stderr, "%d\t", num_rules + 1 );
  69.             beglin = 0;
  70.             }
  71.  
  72.         switch ( toktype )
  73.             {
  74.             case '<':
  75.             case '=':    // CEH
  76.             case '>':
  77.             case '^':
  78.             case '$':
  79.             case '"':
  80.             case '[':
  81.             case ']':
  82.             case '{':
  83.             case '}':
  84.             case '|':
  85.             case '(':
  86.             case ')':
  87.             case '-':
  88.             case '/':
  89.             case '\\':
  90.             case '?':
  91.             case '.':
  92.             case '*':
  93.             case '+':
  94.             case ',':
  95.                 (void) putc( toktype, stderr );
  96.                 break;
  97.  
  98.             case '\n':
  99.                 (void) putc( '\n', stderr );
  100.  
  101.                 if ( sectnum == 2 )
  102.                 beglin = 1;
  103.  
  104.                 break;
  105.  
  106.             case SCDECL:
  107.                 fputs( "%s", stderr );
  108.                 break;
  109.  
  110.             case XSCDECL:
  111.                 fputs( "%x", stderr );
  112.                 break;
  113.  
  114.             case SECTEND:
  115.                 fputs( "%%\n", stderr );
  116.  
  117.                 /* We set beglin to be true so we'll start
  118.                  * writing out numbers as we echo rules.
  119.                  * flexscan() has already assigned sectnum.
  120.                  */
  121.                 if ( sectnum == 2 )
  122.                     beglin = 1;
  123.  
  124.                 break;
  125.  
  126.             case NAME:
  127.                 fprintf( stderr, "'%s'", nmstr );
  128.                 break;
  129.  
  130.             case CHAR:
  131.                 switch ( yylval )
  132.                     {
  133.                     case '<':
  134.                     case '>':
  135.                     case '^':
  136.                     case '$':
  137.                     case '"':
  138.                     case '[':
  139.                     case ']':
  140.                     case '{':
  141.                     case '}':
  142.                     case '|':
  143.                     case '(':
  144.                     case ')':
  145.                     case '-':
  146.                     case '/':
  147.                     case '\\':
  148.                     case '?':
  149.                     case '.':
  150.                     case '*':
  151.                     case '+':
  152.                     case ',':
  153.                         fprintf( stderr, "\\%c",
  154.                             yylval );
  155.                         break;
  156.  
  157.                     default:
  158.                         if ( ! isascii( yylval ) ||
  159.                              ! isprint( yylval ) )
  160.                             fprintf( stderr,
  161.                                 "\\%.3o",
  162.                             (unsigned int) yylval );
  163.                         else
  164.                             (void) putc( yylval,
  165.                                 stderr );
  166.                     break;
  167.                     }
  168.  
  169.                 break;
  170.  
  171.             case NUMBER:
  172.                 fprintf( stderr, "%d", yylval );
  173.                 break;
  174.  
  175.             case PREVCCL:
  176.                 fprintf( stderr, "[%d]", yylval );
  177.                 break;
  178.  
  179.             case EOF_OP:
  180.                 fprintf( stderr, "<<EOF>>" );
  181.                 break;
  182.  
  183.             case OPTION_OP:
  184.                 fprintf( stderr, "%s ", yytext );
  185.                 break;
  186.  
  187.             case OPT_OUTFILE:
  188.             case OPT_PREFIX:
  189.             case CCE_ALNUM:
  190.             case CCE_ALPHA:
  191.             case CCE_BLANK:
  192.             case CCE_CNTRL:
  193.             case CCE_DIGIT:
  194.             case CCE_GRAPH:
  195.             case CCE_LOWER:
  196.             case CCE_PRINT:
  197.             case CCE_PUNCT:
  198.             case CCE_SPACE:
  199.             case CCE_UPPER:
  200.             case CCE_XDIGIT:
  201.                 fprintf( stderr, "%s", yytext );
  202.                 break;
  203.  
  204.             case 0:
  205.                 fprintf( stderr, _( "End Marker\n" ) );
  206.                 break;
  207.  
  208.             default:
  209.                 fprintf( stderr,
  210.                 _( "*Something Weird* - tok: %d val: %d\n" ),
  211.                     toktype, yylval );
  212.                 break;
  213.             }
  214.         }
  215.  
  216.     return toktype;
  217.     }
  218.